.TH std::cosh,std::coshf,std::coshl 3 "2024.06.10" "http://cppreference.com" "C++ Standard Libary"
.SH NAME
std::cosh,std::coshf,std::coshl \- std::cosh,std::coshf,std::coshl

.SH Synopsis
   Defined in header <cmath>
   float       cosh ( float num );

   double      cosh ( double num );                            (until C++23)

   long double cosh ( long double num );
   /* floating-point-type */                                   (since C++23)
               cosh ( /* floating-point-type */ num );         (constexpr since C++26)
   float       coshf( float num );                     \fB(1)\fP \fB(2)\fP \fI(since C++11)\fP
                                                               (constexpr since C++26)
   long double coshl( long double num );                   \fB(3)\fP \fI(since C++11)\fP
                                                               (constexpr since C++26)
   Additional overloads \fI(since C++11)\fP
   Defined in header <cmath>
   template< class Integer >                               (A) (constexpr since C++26)
   double      cosh ( Integer num );

   1-3) Computes the hyperbolic cosine of num.
   The library provides overloads of std::cosh for all cv-unqualified floating-point
   types as the type of the parameter.
   (since C++23)

   A) Additional overloads are provided for all integer types, which are  \fI(since C++11)\fP
   treated as double.

.SH Parameters

   num - floating-point or integer value

.SH Return value

   If no errors occur, the hyperbolic cosine of num (cosh(num), or

   enum
   +e-num
   2

   ) is returned.

   If a range error due to overflow occurs, +HUGE_VAL, +HUGE_VALF, or +HUGE_VALL is
   returned.

.SH Error handling

   Errors are reported as specified in math_errhandling.

   If the implementation supports IEEE floating-point arithmetic (IEC 60559),

     * if the argument is ±0, 1 is returned.
     * If the argument is ±∞, +∞ is returned.
     * if the argument is NaN, NaN is returned.

.SH Notes

   For the IEEE-compatible type double, if |num| > 710.5, then std::cosh(num)
   overflows.

   The additional overloads are not required to be provided exactly as (A). They only
   need to be sufficient to ensure that for their argument num of integer type,
   std::cosh(num) has the same effect as std::cosh(static_cast<double>(num)).

.SH Example


// Run this code

 #include <cerrno>
 #include <cfenv>
 #include <cmath>
 #include <cstring>
 #include <iostream>
 // #pragma STDC FENV_ACCESS ON

 int main()
 {
     const double x = 42;

     std::cout << "cosh(1) = " << std::cosh(1) << '\\n'
               << "cosh(-1) = " << std::cosh(-1) << '\\n'
               << "log(sinh(" << x << ")+cosh(" << x << ")) = "
               << std::log(std::sinh(x) + std::cosh(x)) << '\\n';

     // special values
     std::cout << "cosh(+0) = " << std::cosh(0.0) << '\\n'
               << "cosh(-0) = " << std::cosh(-0.0) << '\\n';

     // error handling
     errno=0;
     std::feclearexcept(FE_ALL_EXCEPT);

     std::cout << "cosh(710.5) = " << std::cosh(710.5) << '\\n';

     if (errno == ERANGE)
         std::cout << "    errno == ERANGE: " << std::strerror(errno) << '\\n';
     if (std::fetestexcept(FE_OVERFLOW))
         std::cout << "    FE_OVERFLOW raised\\n";
 }

.SH Possible output:

 cosh\fB(1)\fP = 1.54308
 cosh(-1) = 1.54308
 log(sinh\fB(42)\fP+cosh(42)) = 42
 cosh(+0) = 1
 cosh(-0) = 1
 cosh(710.5) = inf
     errno == ERANGE: Numerical result out of range
     FE_OVERFLOW raised

.SH See also

   sinh
   sinhf               computes hyperbolic sine (\\({\\small\\sinh{x}}\\)sinh(x))
   sinhl               \fI(function)\fP
   \fI(C++11)\fP
   \fI(C++11)\fP
   tanh
   tanhf               computes hyperbolic tangent (\\({\\small\\tanh{x}}\\)tanh(x))
   tanhl               \fI(function)\fP
   \fI(C++11)\fP
   \fI(C++11)\fP
   acosh
   acoshf              computes the inverse hyperbolic cosine
   acoshl              (\\({\\small\\operatorname{arcosh}{x}}\\)arcosh(x))
   \fI(C++11)\fP             \fI(function)\fP
   \fI(C++11)\fP
   \fI(C++11)\fP
                       computes hyperbolic cosine of a complex number
   cosh(std::complex)  (\\({\\small\\cosh{z}}\\)cosh(z))
                       \fI(function template)\fP
   cosh(std::valarray) applies the function std::cosh to each element of valarray
                       \fI(function template)\fP
   C documentation for
   cosh
